/**
 * Tools Store
 * 负责管理tools相关的状态和数据处理
 */

import { observable, action  } from 'mobx-miniprogram';

// 工具模块Store
export const toolsStore = observable({
  // 工具列表数据
  toolsList: [],
  
  // 常用工具
  frequentTools: [],
  
  // 工具分类
  categories: [],
  
  // 当前选中的工具
  currentTool: null,
  
  // 工具搜索条件
  filter: {
    category: '',
    searchKey: ''
  },
  
  // 使用历史
  usageHistory: [],
  
  // 页面加载状态
  loading: false,
  
  // 计算属性：筛选后的工具列表
  get filteredTools() {
    if (!this.toolsList.length) return [];
    
    let filtered = [...this.toolsList];
    
    // 根据分类筛选
    if (this.filter.category) {
      filtered = filtered.filter(t => t.category === this.filter.category);
    }
    
    // 根据关键词搜索
    if (this.filter.searchKey) {
      const key = this.filter.searchKey.toLowerCase();
      filtered = filtered.filter(t => 
        t.name.toLowerCase().includes(key) || 
        t.description.toLowerCase().includes(key) ||
        (t.tags && t.tags.some(tag => tag.toLowerCase().includes(key)))
      );
    }
    
    return filtered;
  },
  
  // 计算属性：按分类分组的工具列表
  get toolsByCategory() {
    const result = {};
    
    this.categories.forEach(category => {
      result[category.id] = this.toolsList.filter(tool => tool.category === category.id);
    });
    
    return result;
  },
  
  // Action: 设置工具列表
  setToolsList: action(function(tools) {
    this.toolsList = tools;
    this.updateFrequentTools();
  }),
  
  // Action: 设置工具分类
  setCategories: action(function(categories) {
    this.categories = categories;
  }),
  
  // Action: 设置当前工具
  setCurrentTool: action(function(toolId) {
    this.currentTool = this.toolsList.find(t => t._id === toolId) || null;
    
    // 如果找到工具，记录使用历史
    if (this.currentTool) {
      this.recordToolUsage(this.currentTool._id);
    }
  }),
  
  // Action: 记录工具使用
  recordToolUsage: action(function(toolId) {
    // 检查是否已存在于历史记录中
    const existingIndex = this.usageHistory.findIndex(h => h.toolId === toolId);
    
    const now = dayjs();
    
    if (existingIndex >= 0) {
      // 已存在，更新使用次数和最后使用时间
      this.usageHistory[existingIndex].useCount++;
      this.usageHistory[existingIndex].lastUsed = now;
    } else {
      // 不存在，添加新记录
      this.usageHistory.push({
        toolId,
        useCount: 1,
        firstUsed: now,
        lastUsed: now
      });
    }
    
    // 更新常用工具列表
    this.updateFrequentTools();
  }),
  
  // Action: 更新常用工具列表
  updateFrequentTools: action(function() {
    // 按使用次数排序
    const sortedHistory = [...this.usageHistory].sort((a, b) => b.useCount - a.useCount);
    
    // 获取前5个常用工具
    this.frequentTools = sortedHistory.slice(0, 5).map(h => {
      return this.toolsList.find(t => t._id === h.toolId);
    }).filter(t => t); // 过滤掉可能不存在的工具
  }),
  
  // Action: 设置过滤条件
  setFilter: action(function(filter) {
    this.filter = {...this.filter, ...filter};
  }),
  
  // Action: 清空过滤条件
  clearFilter: action(function() {
    this.filter = {
      category: '',
      searchKey: ''
    };
  }),
  
  // Action: 设置加载状态
  setLoading: action(function(loading) {
    this.loading = loading;
  })
});

// 缓存管理器Store
export const cacheManagerStore = observable({
  // 缓存统计数据
  cacheStats: null,
  
  // 缓存分组列表
  cacheGroups: [],
  
  // 操作面板
  showActionSheet: false,
  actionItems: ['清理全部缓存', '清理选定分组', '清理低优先级缓存', '缓存详情'],
  currentAction: null,
  currentGroup: null,
  
  // 页面状态
  isLoad: false,
  isAdmin: false,
  
  // 计算属性：获取总缓存使用百分比
  get totalCacheUsage() {
    if (!this.cacheStats || !this.cacheStats.total) return 0;
    return parseFloat(((this.cacheStats.total.size / this.cacheStats.total.limit) * 100).toFixed(1));
  },
  
  // 计算属性：获取总缓存大小格式化后的字符串
  get totalCacheSize() {
    if (!this.cacheStats || !this.cacheStats.total) return '0 KB';
    return this.cacheStats.total.size.toFixed(2) + ' KB';
  },
  
  // Action: 设置缓存统计数据
  setCacheStats: action(function(stats) {
    this.cacheStats = stats;
  }),
  
  // Action: 设置缓存分组列表
  setCacheGroups: action(function(groups) {
    this.cacheGroups = groups;
  }),
  
  // Action: 设置当前选中的分组
  setCurrentGroup: action(function(group) {
    this.currentGroup = group;
  }),
  
  // Action: 设置操作面板显示状态
  setShowActionSheet: action(function(show) {
    this.showActionSheet = show;
  }),
  
  // Action: 设置当前操作
  setCurrentAction: action(function(action) {
    this.currentAction = action;
  }),
  
  // Action: 设置加载和管理员状态
  setPageState: action(function(isLoad, isAdmin) {
    this.isLoad = isLoad;
    this.isAdmin = isAdmin;
  }),
  
  // Action: 格式化缓存统计数据
  formatCacheStats: action(function(rawStats) {
    if (!rawStats) return null;
    
    return {
      total: {
        count: rawStats.total.count,
        size: rawStats.total.size.toFixed(2),
        limit: rawStats.total.limit,
        usage: ((rawStats.total.size / rawStats.total.limit) * 100).toFixed(1),
        color: this.getUsageColor(rawStats.total.size, rawStats.total.limit)
      }
    };
  }),
  
  // Action: 根据使用率获取颜色
  getUsageColor: action(function(size, limit) {
    if (limit <= 0) return '#999999';
    
    const usage = (size / limit) * 100;
    
    if (usage >= 80) {
      return '#ff0000'; // 危险红色
    } else if (usage >= 60) {
      return '#ff9900'; // 警告橙色
    } else {
      return '#0066cc'; // 正常蓝色
    }
  }),
  
  // Action: 加载缓存统计数据
  loadCacheStats: action(async function() {
    try {
      import cacheHelper from '../../../helpers/cacheHelper.js';
      import pageHelper from '../../../helpers/pageHelper.js';
      
      const stats = cacheHelper.getStats();
      if (!stats) {
        pageHelper.showModal('获取缓存统计失败', '请稍后重试');
        return false;
      }
      
      // 格式化统计数据用于显示
      const formattedStats = this.formatCacheStats(stats);
      
      // 提取分组数据
      const groups = [];
      for (const groupName in stats.groups) {
        const groupData = stats.groups[groupName];
        groups.push({
          name: groupName,
          count: groupData.count,
          size: groupData.size.toFixed(2),
          limit: groupData.limit,
          usage: groupData.limit > 0 ? ((groupData.size / groupData.limit) * 100).toFixed(1) : 0,
          color: this.getUsageColor(groupData.size, groupData.limit)
        });
      }
      
      // 设置数据
      this.setCacheStats(formattedStats);
      this.setCacheGroups(groups);
      
      return true;
    } catch (err) {
      console.error('加载缓存统计失败:', err);
      import pageHelper from '../../../helpers/pageHelper.js';
      pageHelper.showModal('加载失败', '获取缓存统计信息失败');
      return false;
    }
  }),
  
  // Action: 清理全部缓存
  clearAllCache: action(async function() {
    try {
      import cacheHelper from '../../../helpers/cacheHelper.js';
      import pageHelper from '../../../helpers/pageHelper.js';
      
      cacheHelper.clear();
      pageHelper.showSuccToast('缓存清理成功');
      
      // 重新加载统计数据
      setTimeout(() => {
        this.loadCacheStats();
      }, 500);
      
      return true;
    } catch (err) {
      console.error('清理全部缓存失败:', err);
      import pageHelper from '../../../helpers/pageHelper.js';
      pageHelper.showModal('操作失败', '清理全部缓存失败，请稍后重试');
      return false;
    }
  }),
  
  // Action: 清理指定分组的缓存
  clearGroupCache: action(async function(group) {
    if (!group) return false;
    
    try {
      import cacheHelper from '../../../helpers/cacheHelper.js';
      import pageHelper from '../../../helpers/pageHelper.js';
      
      cacheHelper.clearGroup(group);
      pageHelper.showSuccToast(`${group} 分组缓存清理成功`);
      
      // 重新加载统计数据
      setTimeout(() => {
        this.loadCacheStats();
      }, 500);
      
      return true;
    } catch (err) {
      console.error(`清理 ${group} 分组缓存失败:`, err);
      import pageHelper from '../../../helpers/pageHelper.js';
      pageHelper.showModal('操作失败', `清理 ${group} 分组缓存失败，请稍后重试`);
      return false;
    }
  }),
  
  // Action: 清理低优先级缓存
  clearLowPriorityCache: action(async function() {
    try {
      import cacheHelper from '../../../helpers/cacheHelper.js';
      import pageHelper from '../../../helpers/pageHelper.js';
      
      // 获取所有分组
      const groups = Object.values(cacheHelper.CACHE_GROUP);
      
      // 对每个分组执行低优先级清理
      groups.forEach(group => {
        // 这里我们调用内部实现的清理方法，仅清理优先级为LOW的缓存
        const cleanByPriority = cacheHelper.__cleanCacheByPriority || null;
        if (typeof cleanByPriority === 'function') {
          cleanByPriority(group, cacheHelper.CACHE_PRIORITY.LOW);
        }
      });
      
      pageHelper.showSuccToast('低优先级缓存清理成功');
      
      // 重新加载统计数据
      setTimeout(() => {
        this.loadCacheStats();
      }, 500);
      
      return true;
    } catch (err) {
      console.error('清理低优先级缓存失败:', err);
      import pageHelper from '../../../helpers/pageHelper.js';
      pageHelper.showModal('操作失败', '清理低优先级缓存失败，请稍后重试');
      return false;
    }
  }),
  
  // Action: 处理操作面板点击
  handleActionClick: action(function(index) {
    const item = this.actionItems[index];
    this.setShowActionSheet(false);
    this.setCurrentAction(item);
    
    // 根据操作类型执行不同的方法
    switch (index) {
      case 0: // 清理全部缓存
        return this.clearAllCache();
        
      case 1: // 清理选定分组
        if (this.currentGroup) {
          return this.clearGroupCache(this.currentGroup);
        } else {
          import pageHelper from '../../../helpers/pageHelper.js';
          pageHelper.showToast('未选择分组');
          return false;
        }
        
      case 2: // 清理低优先级缓存
        return this.clearLowPriorityCache();
        
      case 3: // 缓存详情
        return this.showCacheDetails();
        
      default:
        return false;
    }
  }),
  
  // Action: 显示缓存详情
  showCacheDetails: action(function() {
    import pageHelper from '../../../helpers/pageHelper.js';
    
    if (!this.cacheStats || !this.cacheGroups.length) {
      pageHelper.showToast('缓存信息不可用');
      return false;
    }
    
    let detailContent = `【缓存统计】\n`;
    detailContent += `总缓存数: ${this.cacheStats.total.count} 项\n`;
    detailContent += `总缓存大小: ${this.cacheStats.total.size} KB\n`;
    detailContent += `总缓存使用率: ${this.cacheStats.total.usage}%\n\n`;
    
    detailContent += `【分组缓存】\n`;
    this.cacheGroups.forEach(group => {
      detailContent += `${group.name}: ${group.count}项, ${group.size}KB (${group.usage}%)\n`;
    });
    
    pageHelper.showModal('缓存详情', detailContent);
    return true;
  })
}); 